package com.Algorithm.HUAWEI.two20220303;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: zjz
 * @Date: 2022/03/21/18:18
 * @Description:
 * @Target:
 */
public class 字符串加密 {

    /*
    *
    * 有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，
    * 如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，将所得结果作为新字母表开头，
    * 并将新建立的字母表中未出现的字母按照正常字母表顺序加入新字母表。如下所示：
        A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

        T R A I L B Z E S C D F G H J K M N O P Q U V W X Y (实际需建立小写字母的字母表，此字母表仅为方便演示）
        T R A I L B Z E S C D F G H J K M N O P Q U V W X

        上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，
        * 并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。
        * 因此，使用这个密匙， Attack AT DAWN (黎明时攻击)就会被加密为Tpptad TP ITVH。

        请实现下述接口，通过指定的密匙和明文得到密文。

        数据范围：1 \le n \le 100 \1≤n≤100  ，保证输入的字符串中仅包含小写字母

        输入描述：
        先输入key和要加密的字符串

        输出描述：
        返回加密后的字符串

        示例1
        输入：
        nihao
        ni
        复制
        输出：
        le

    *
    *
    * */


    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String s1 = in.readLine();
        String s2 = in.readLine();

        char[] chars = buildSwapDictionary(s1);
        for (int i = 0; i < s2.length(); i++) {
            System.out.print(getRes(s2.charAt(i),chars));
        }

    }


    // 获取返回值
    static char getRes(char c,char[] chars){
        if (checkRange(c,'a','z') ){
            return chars[c-'a'+26];
        }else if (checkRange(c,'A','Z')){
            return chars[c-'A'];
        }else {
            return c;
        }
    }

    // 数组字典，一段字母进来，不足26，建立数据字典
    static char[] buildSwapDictionary(String ss){
        char[] chars = new char[52];  // 0-25大写，26-51小写
        int index = 0;
        HashSet set = new HashSet();

            for (int i = 0; i < ss.length(); i++) {
                if (set.contains(ss.charAt(i))){
                    continue;
                }else {
                if (checkRange(ss.charAt(i),'a','z')){
                    set.add((char) (ss.charAt(i)-32));
                    set.add(ss.charAt(i));
                    chars[index+26] = ss.charAt(i);
                    chars[index] = (char) (ss.charAt(i)-32);
                    index++;

                }else if (checkRange(ss.charAt(i),'A','Z')){
                    set.add((char)(ss.charAt(i)+32));
                    set.add(ss.charAt(i));
                    chars[index+26] = (char)(ss.charAt(i)+32);
                    chars[index] = ss.charAt(i);
                    index++;
                }
                }

            }

        for (int i = 0; i < 26; i++) {
            if (index<26&&!set.contains((char)('A'+i))){
                set.add((char)('A'+i+32));
                set.add((char)('A'+i));
                chars[index+26] = (char)('A'+i+32);
                chars[index] = (char)('A'+i);
                index++;
            }
        }
        return chars;

    }

    static boolean checkRange(char c,char a,char b){
        if (c<a||c>b){
            return false;
        }else {
            return true;
        }
    }
}
